/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/* inffast.h -- header to use inffast.c
 * Copyright (C) 1995-2003, 2010 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* WARNING: this file should *not* be used by applications. It is
   part of the implementation of the compression library and is
   subject to change. Applications should only use zlib.h.
 */

/*
 * The chunk-copy code below deals with writing the decoded DEFLATE data to
 * the output with SIMD methods to increase decode speed. Reading the input
 * to the DEFLATE decoder with a wide, SIMD method can also increase decode
 * speed. This option is supported on little endian machines, and reads the
 * input data in 64-bit (8 byte) chunks.
 */

void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start));

#if defined(INFLATE_CHUNK_SIMD_NEON)

#include <stdint.h>
#include "zutil.h"
#include <arm_neon.h>

typedef uint8x16_t z_vec128i_t;

#define Z_STATIC_ASSERT(name, assert) typedef char name[(assert) ? 1 : -1]

#if __STDC_VERSION__ >= 199901L
#define Z_RESTRICT restrict
#else
#define Z_RESTRICT
#endif

#if defined(__clang__) || defined(__GNUC__) || defined(__llvm__)
#define Z_BUILTIN_MEMCPY __builtin_memcpy
#else
#define Z_BUILTIN_MEMCPY zmemcpy
#endif

/*
 * chunk copy type: the z_vec128i_t type size should be exactly 128-bits
 * and equal to CHUNKCOPY_CHUNK_SIZE.
 */
#define CHUNKCOPY_CHUNK_SIZE sizeof(z_vec128i_t)

Z_STATIC_ASSERT(vector_128_bits_wide,
                CHUNKCOPY_CHUNK_SIZE == sizeof(int8_t) * 16);

/*
 * Ask the compiler to perform a wide, unaligned load with a machinevst1q_u8
 * instruction appropriate for the z_vec128i_t type.
 */
static inline z_vec128i_t loadchunk(
    const unsigned char FAR* s)
{
    z_vec128i_t v;
    Z_BUILTIN_MEMCPY(&v, s, sizeof(v));
    return v;
}

/*
 * Ask the compiler to perform a wide, unaligned store with a machine
 * instruction appropriate for the z_vec128i_t type.
 */
static inline void storechunk(
    unsigned char FAR* d,
    const z_vec128i_t v)
{
    Z_BUILTIN_MEMCPY(d, &v, sizeof(v));
}

/*
 * Perform a memcpy-like operation, assuming that length is non-zero and that
 * it's OK to overwrite at least CHUNKCOPY_CHUNK_SIZE bytes of output even if
 * the length is shorter than this.
 *
 * It also guarantees that it will properly unroll the data if the distance
 * between `out` and `from` is at least CHUNKCOPY_CHUNK_SIZE, which we rely on
 * in chunkcopy_relaxed().
 *
 * Aside from better memory bus utilisation, this means that short copies
 * (CHUNKCOPY_CHUNK_SIZE bytes or fewer) will fall straight through the loop
 * without iteration, which will hopefully make the branch prediction more
 * reliable.
 */
static inline unsigned char FAR* chunkcopy_core(
    unsigned char FAR* out,
    const unsigned char FAR* from,
    unsigned len)
{
    const int bump = (--len % CHUNKCOPY_CHUNK_SIZE) + 1;
    storechunk(out, loadchunk(from));
    out += bump;
    from += bump;
    len /= CHUNKCOPY_CHUNK_SIZE;
    while (len-- > 0) {
        storechunk(out, loadchunk(from));
        out += CHUNKCOPY_CHUNK_SIZE;
        from += CHUNKCOPY_CHUNK_SIZE;
    }
    return out;
}

/*
 * Like chunkcopy_core(), but avoid writing beyond of legal output.
 *
 * Accepts an additional pointer to the end of safe output.  A generic safe
 * copy would use (out + len), but it's normally the case that the end of the
 * output buffer is beyond the end of the current copy, and this can still be
 * exploited.
 */
static inline unsigned char FAR* chunkcopy_core_safe(
    unsigned char FAR* out,
    const unsigned char FAR* from,
    unsigned len,
    unsigned char FAR* limit)
{
    Assert(out + len <= limit, "chunk copy exceeds safety limit");
    if ((limit - out) < (ptrdiff_t) CHUNKCOPY_CHUNK_SIZE) {
        const unsigned char FAR* Z_RESTRICT rfrom = from;
        if (len & 8) {
            Z_BUILTIN_MEMCPY(out, rfrom, 8);
            out += 8;
            rfrom += 8;
        }
        if (len & 4) {
            Z_BUILTIN_MEMCPY(out, rfrom, 4);
            out += 4;
            rfrom += 4;
        }
        if (len & 2) {
            Z_BUILTIN_MEMCPY(out, rfrom, 2);
            out += 2;
            rfrom += 2;
        }
        if (len & 1) {
            *out++ = *rfrom++;
        }
        return out;
    }
    return chunkcopy_core(out, from, len);
}

/*
 * Perform short copies until distance can be rewritten as being at least
 * CHUNKCOPY_CHUNK_SIZE.
 *
 * Assumes it's OK to overwrite at least the first 2*CHUNKCOPY_CHUNK_SIZE
 * bytes of output even if the copy is shorter than this.  This assumption
 * holds within zlib inflate_fast(), which starts every iteration with at
 * least 258 bytes of output space available (258 being the maximum length
 * output from a single token; see inffast.c).
 */
static inline unsigned char FAR* chunkunroll_relaxed(
    unsigned char FAR* out,
    unsigned FAR* dist,
    unsigned FAR* len)
{
    const unsigned char FAR* from = out - *dist;
    while (*dist < *len && *dist < CHUNKCOPY_CHUNK_SIZE) {
        storechunk(out, loadchunk(from));
        out += *dist;
        *len -= *dist;
        *dist += *dist;
    }
    return out;
}

/*
 * v_load64_dup(): load *src as an unaligned 64-bit int and duplicate it in
 * every 64-bit component of the 128-bit result (64-bit int splat).
 */
static inline z_vec128i_t v_load64_dup(const void* src)
{
    return vcombine_u8(vld1_u8(src), vld1_u8(src));
}

/*
 * v_load32_dup(): load *src as an unaligned 32-bit int and duplicate it in
 * every 32-bit component of the 128-bit result (32-bit int splat).
 */
static inline z_vec128i_t v_load32_dup(const void* src)
{
    int32_t i32;
    Z_BUILTIN_MEMCPY(&i32, src, sizeof(i32));
    return vreinterpretq_u8_s32(vdupq_n_s32(i32));
}

/*
 * v_load16_dup(): load *src as an unaligned 16-bit int and duplicate it in
 * every 16-bit component of the 128-bit result (16-bit int splat).
 */
static inline z_vec128i_t v_load16_dup(const void* src)
{
    int16_t i16;
    Z_BUILTIN_MEMCPY(&i16, src, sizeof(i16));
    return vreinterpretq_u8_s16(vdupq_n_s16(i16));
}

/*
 * v_load8_dup(): load the 8-bit int *src and duplicate it in every 8-bit
 * component of the 128-bit result (8-bit int splat).
 */
static inline z_vec128i_t v_load8_dup(const void* src)
{
    return vld1q_dup_u8((const uint8_t*) src);
}

/*
 * v_store_128(): store the 128-bit vec in a memory destination (that might
 * not be 16-byte aligned) void* out.
 */
static inline void v_store_128(unsigned char* out, const z_vec128i_t vec)
{
    vst1q_u8(out, vec);
}

/*
 * Perform an overlapping copy which behaves as a memset() operation, but
 * supporting periods other than one, and assume that length is non-zero and
 * that it's OK to overwrite at least CHUNKCOPY_CHUNK_SIZE*3 bytes of output
 * even if the length is shorter than this.
 */
static inline unsigned char FAR* chunkset_store_result(
    unsigned len,
    unsigned char FAR* out,
    z_vec128i_t v)
{
    do {
        v_store_128(out, v);
        out += sizeof(v);
        len -= sizeof(v);
    } while (len > 0);
    return out;
}

static inline unsigned char FAR* chunkset_core(unsigned char FAR* out, unsigned period, unsigned len)
{
    z_vec128i_t v;
    const int bump = ((len - 1) % sizeof(v)) + 1;
    switch (period) {
        case 1:
            v = v_load8_dup(out - 1);
            v_store_128(out, v);
            out += bump;
            len -= bump;
            while (len > 0) {
                v_store_128(out, v);
                out += sizeof(v);
                len -= sizeof(v);
            }
            return out;
        case 2:
            v = v_load16_dup(out - 2);
            v_store_128(out, v);
            out += bump;
            len -= bump;
            if (len > 0) {
                v = v_load16_dup(out - 2);
                out = chunkset_store_result(len, out, v);
            }
            return out;
        case 4:
            v = v_load32_dup(out - 4);
            v_store_128(out, v);
            out += bump;
            len -= bump;
            if (len > 0) {
                v = v_load32_dup(out - 4);
                out = chunkset_store_result(len, out, v);
            }
            return out;
        case 8:
            v = v_load64_dup(out - 8);
            v_store_128(out, v);
            out += bump;
            len -= bump;
            if (len > 0) {
                v = v_load64_dup(out - 8);
                out = chunkset_store_result(len, out, v);
            }
            return out;
    }
    out = chunkunroll_relaxed(out, &period, &len);
    return chunkcopy_core(out, out - period, len);
}

/*
 * Perform a memcpy-like operation, but assume that length is non-zero and that
 * it's OK to overwrite at least CHUNKCOPY_CHUNK_SIZE bytes of output even if
 * the length is shorter than this.
 *
 * Unlike chunkcopy_core() above, no guarantee is made regarding the behaviour
 * of overlapping buffers, regardless of the distance between the pointers.
 * This is reflected in the `restrict`-qualified pointers, allowing the
 * compiler to re-order loads and stores.
 */
static inline unsigned char FAR* chunkcopy_relaxed(
    unsigned char FAR* Z_RESTRICT out,
    const unsigned char FAR* Z_RESTRICT from,
    unsigned len)
{
    return chunkcopy_core(out, from, len);
}

/*
 * Like chunkcopy_relaxed(), but avoid writing beyond of legal output.
 *
 * Unlike chunkcopy_core_safe() above, no guarantee is made regarding the
 * behaviour of overlapping buffers, regardless of the distance between the
 * pointers.  This is reflected in the `restrict`-qualified pointers, allowing
 * the compiler to re-order loads and stores.
 *
 * Accepts an additional pointer to the end of safe output.  A generic safe
 * copy would use (out + len), but it's normally the case that the end of the
 * output buffer is beyond the end of the current copy, and this can still be
 * exploited.
 */
static inline unsigned char FAR* chunkcopy_safe(
    unsigned char FAR* out,
    const unsigned char FAR* Z_RESTRICT from,
    unsigned len,
    unsigned char FAR* limit)
{
    Assert(out + len <= limit, "chunk copy exceeds safety limit");
    return chunkcopy_core_safe(out, from, len, limit);
}

/*
 * Perform chunky copy within the same buffer, where the source and destination
 * may potentially overlap.
 *
 * Assumes that len > 0 on entry, and that it's safe to write at least
 * CHUNKCOPY_CHUNK_SIZE*3 bytes to the output.
 */
static inline unsigned char FAR* chunkcopy_lapped_relaxed(
    unsigned char FAR* out,
    unsigned dist,
    unsigned len)
{
    if (dist < len && dist < CHUNKCOPY_CHUNK_SIZE) {
        return chunkset_core(out, dist, len);
    }
    return chunkcopy_core(out, out - dist, len);
}

/*
 * Behave like chunkcopy_lapped_relaxed(), but avoid writing beyond of legal
 * output.
 *
 * Accepts an additional pointer to the end of safe output.  A generic safe
 * copy would use (out + len), but it's normally the case that the end of the
 * output buffer is beyond the end of the current copy, and this can still be
 * exploited.
 */
static inline unsigned char FAR* chunkcopy_lapped_safe(
    unsigned char FAR* out,
    unsigned dist,
    unsigned len,
    unsigned char FAR* limit)
{
    Assert(out + len <= limit, "chunk copy exceeds safety limit");
    if ((limit - out) < (ptrdiff_t) (3 * CHUNKCOPY_CHUNK_SIZE)) {
        while (len-- > 0) {
            *out = *(out - dist);
            out++;
        }
        return out;
    }
    return chunkcopy_lapped_relaxed(out, dist, len);
}


#undef Z_STATIC_ASSERT
#undef Z_RESTRICT
#undef Z_BUILTIN_MEMCPY

#endif //defined(INFLATE_CHUNK_SIMD_NEON)
